package com.ourteam.product.ui.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-12-14 15:15:15 Warning ! This file will be overwrite when
 * regenerate !
 */
public class ProductUITreeNodeBuilderDAOQueryBean extends BaseQueryBean {

  public ProductUITreeNodeBuilderDAOQueryBean() {
    super();
  }

  public ProductUITreeNodeBuilderDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public ProductUITreeNodeBuilderDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Id, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Id, "id");
    }
  }

  public void addNodeIdSelectProperty() {
    addNodeIdSelectProperty("nodeId");
  }

  public void addNodeIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.NodeId, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.NodeId, "nodeId");
    }
  }

  public void addCodeSelectProperty() {
    addCodeSelectProperty("code");
  }

  public void addCodeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Code, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Code, "code");
    }
  }

  public void addNodeBuilderSelectProperty() {
    addNodeBuilderSelectProperty("nodeBuilder");
  }

  public void addNodeBuilderSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.NodeBuilder, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.NodeBuilder, "nodeBuilder");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Status, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.Remarks, "remarks");
    }
  }

  public void addSortIndexSelectProperty() {
    addSortIndexSelectProperty("sortIndex");
  }

  public void addSortIndexSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUITreeNodeBuilderDAO.SortIndex, aAlias);
    } else {
      addSelectProperty(IProductUITreeNodeBuilderDAO.SortIndex, "sortIndex");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addNodeIdSelectProperty();

    addCodeSelectProperty();

    addNodeBuilderSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addSortIndexSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<ProductUITreeNodeBuilderDAOQueryBean> {

    protected Criteria(ProductUITreeNodeBuilderDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.Id
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.Id
              + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.Id
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Id
              + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.Id
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Id
              + " <>",
          value,
          "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andNodeIdIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " is null");
      return this;
    }

    public Criteria andNodeIdIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " is not null");
      return this;
    }

    public Criteria andNodeIdIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeId
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.NodeId
              + " <> ''");
      return this;
    }

    public Criteria andNodeIdIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.NodeId
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.NodeId
              + " = '')");
      return this;
    }

    public Criteria andNodeIdEqualTo(long value) {
      return andNodeIdEqualTo(Long.valueOf(value));
    }

    public Criteria andNodeIdEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " = ", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdNotEqualTo(long value) {
      return andNodeIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andNodeIdNotEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " <>", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdNotEqualToOrIsNull(long value) {
      return andNodeIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andNodeIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeId
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.NodeId
              + " <>",
          value,
          "nodeId");
      return this;
    }

    public Criteria andNodeIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdGreaterThan(long value) {
      return andNodeIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andNodeIdGreaterThan(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " >", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdGreaterThanOrEqualTo(long value) {
      return andNodeIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andNodeIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " >=", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdLessThan(long value) {
      return andNodeIdLessThan(Long.valueOf(value));
    }

    public Criteria andNodeIdLessThan(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " <", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdLessThanOrEqualTo(long value) {
      return andNodeIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andNodeIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " <=", value, "nodeId");
      return this;
    }

    public Criteria andNodeIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdIn(long[] values) {
      if (values.length == 1) {
        return andNodeIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " in", values, "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdNotIn(long[] values) {
      if (values.length == 1) {
        return andNodeIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " not in", values, "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andNodeIdEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " in", values, "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andNodeIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " not in", values, "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andNodeIdEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " in", Arrays.asList(values), "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andNodeIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.NodeId + " not in", Arrays.asList(values), "nodeId");
        return this;
      }
    }

    public Criteria andNodeIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeIdBetween(long value1, long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " between", value1, value2, "nodeId");
      return this;
    }

    public Criteria andNodeIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " between", value1, value2, "nodeId");
      return this;
    }

    public Criteria andNodeIdNotBetween(long value1, long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " not between", value1, value2, "nodeId");
      return this;
    }

    public Criteria andNodeIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeId + " not between", value1, value2, "nodeId");
      return this;
    }

    public Criteria andCodeIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " is null");
      return this;
    }

    public Criteria andCodeIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " is not null");
      return this;
    }

    public Criteria andCodeIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.Code
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.Code
              + " <> ''");
      return this;
    }

    public Criteria andCodeIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.Code
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Code
              + " = '')");
      return this;
    }

    public Criteria andCodeEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " = ", value, "code");
      return this;
    }

    public Criteria andCodeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeNotEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " <>", value, "code");
      return this;
    }

    public Criteria andCodeNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.Code
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Code
              + " <>",
          value,
          "code");
      return this;
    }

    public Criteria andCodeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeGreaterThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " >", value, "code");
      return this;
    }

    public Criteria andCodeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " >=", value, "code");
      return this;
    }

    public Criteria andCodeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeLessThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " <", value, "code");
      return this;
    }

    public Criteria andCodeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeLessThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Code + " <=", value, "code");
      return this;
    }

    public Criteria andCodeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Code);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCodeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " like", buffer.toString(), "code");
      return this;
    }

    public Criteria andCodeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " not like", buffer.toString(), "code");
      return this;
    }

    public Criteria andCodeIn(List<String> values) {

      if (values.size() == 1) {
        return andCodeEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Code + " in", values, "code");
        return this;
      }
    }

    public Criteria andCodeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCodeNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Code + " not in", values, "code");
        return this;
      }
    }

    public Criteria andCodeIn(String[] values) {

      if (values.length == 1) {
        return andCodeEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Code + " in", Arrays.asList(values), "code");
        return this;
      }
    }

    public Criteria andCodeNotIn(String[] values) {
      if (values.length == 1) {
        return andCodeNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Code + " not in", Arrays.asList(values), "code");
        return this;
      }
    }

    public Criteria andCodeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCodeBetween(String value1, String value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " between", value1, value2, "code");
      return this;
    }

    public Criteria andCodeNotBetween(String value1, String value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Code + " not between", value1, value2, "code");
      return this;
    }

    public Criteria andNodeBuilderIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " is null");
      return this;
    }

    public Criteria andNodeBuilderIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " is not null");
      return this;
    }

    public Criteria andNodeBuilderIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.NodeBuilder
              + " <> ''");
      return this;
    }

    public Criteria andNodeBuilderIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.NodeBuilder
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.NodeBuilder
              + " = '')");
      return this;
    }

    public Criteria andNodeBuilderEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " = ", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderNotEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " <>", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.NodeBuilder
              + " <>",
          value,
          "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderGreaterThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " >", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " >=", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderLessThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " <", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderLessThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " <=", value, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.NodeBuilder);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNodeBuilderLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder + " like", buffer.toString(), "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder + " not like", buffer.toString(), "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderIn(List<String> values) {

      if (values.size() == 1) {
        return andNodeBuilderEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " in", values, "nodeBuilder");
        return this;
      }
    }

    public Criteria andNodeBuilderNotIn(List<String> values) {
      if (values.size() == 1) {
        return andNodeBuilderNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " not in", values, "nodeBuilder");
        return this;
      }
    }

    public Criteria andNodeBuilderIn(String[] values) {

      if (values.length == 1) {
        return andNodeBuilderEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.NodeBuilder + " in", Arrays.asList(values), "nodeBuilder");
        return this;
      }
    }

    public Criteria andNodeBuilderNotIn(String[] values) {
      if (values.length == 1) {
        return andNodeBuilderNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.NodeBuilder + " not in",
            Arrays.asList(values),
            "nodeBuilder");
        return this;
      }
    }

    public Criteria andNodeBuilderIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.NodeBuilder + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNodeBuilderBetween(String value1, String value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder + " between", value1, value2, "nodeBuilder");
      return this;
    }

    public Criteria andNodeBuilderNotBetween(String value1, String value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.NodeBuilder + " not between", value1, value2, "nodeBuilder");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.Status
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.Status
              + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.Status
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.Status
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Status
              + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.Remarks
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.Remarks
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.Remarks
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.Remarks
              + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IProductUITreeNodeBuilderDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IProductUITreeNodeBuilderDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andSortIndexIsNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " is null");
      return this;
    }

    public Criteria andSortIndexIsNotNull() {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " is not null");
      return this;
    }

    public Criteria andSortIndexIsNotEmpty() {
      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex
              + " is not null AND "
              + IProductUITreeNodeBuilderDAO.SortIndex
              + " <> ''");
      return this;
    }

    public Criteria andSortIndexIsEmpty() {
      addCriterion(
          "("
              + IProductUITreeNodeBuilderDAO.SortIndex
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.SortIndex
              + " = '')");
      return this;
    }

    public Criteria andSortIndexEqualTo(int value) {
      return andSortIndexEqualTo(Integer.valueOf(value));
    }

    public Criteria andSortIndexEqualTo(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " = ", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexNotEqualTo(int value) {
      return andSortIndexNotEqualTo(Integer.valueOf(value));
    }

    public Criteria andSortIndexNotEqualTo(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " <>", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexNotEqualToOrIsNull(int value) {
      return andSortIndexNotEqualToOrIsNull(Integer.valueOf(value));
    }

    public Criteria andSortIndexNotEqualToOrIsNull(java.lang.Integer value) {

      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex
              + " is null OR "
              + IProductUITreeNodeBuilderDAO.SortIndex
              + " <>",
          value,
          "sortIndex");
      return this;
    }

    public Criteria andSortIndexNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexGreaterThan(int value) {
      return andSortIndexGreaterThan(Integer.valueOf(value));
    }

    public Criteria andSortIndexGreaterThan(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " >", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexGreaterThanOrEqualTo(int value) {
      return andSortIndexGreaterThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andSortIndexGreaterThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " >=", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexLessThan(int value) {
      return andSortIndexLessThan(Integer.valueOf(value));
    }

    public Criteria andSortIndexLessThan(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " <", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexLessThanOrEqualTo(int value) {
      return andSortIndexLessThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andSortIndexLessThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " <=", value, "sortIndex");
      return this;
    }

    public Criteria andSortIndexLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUITreeNodeBuilderDAO.SortIndex);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSortIndexLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexIn(int[] values) {
      if (values.length == 1) {
        return andSortIndexEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " in", values, "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexNotIn(int[] values) {
      if (values.length == 1) {
        return andSortIndexNotEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " not in", values, "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexIn(List<java.lang.Integer> values) {

      if (values.size() == 1) {
        return andSortIndexEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " in", values, "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexNotIn(List<java.lang.Integer> values) {
      if (values.size() == 1) {
        return andSortIndexNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " not in", values, "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexIn(java.lang.Integer[] values) {

      if (values.length == 1) {
        return andSortIndexEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.SortIndex + " in", Arrays.asList(values), "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexNotIn(java.lang.Integer[] values) {
      if (values.length == 1) {
        return andSortIndexNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUITreeNodeBuilderDAO.SortIndex + " not in", Arrays.asList(values), "sortIndex");
        return this;
      }
    }

    public Criteria andSortIndexIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUITreeNodeBuilderDAO.SortIndex + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSortIndexBetween(int value1, int value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex + " between", value1, value2, "sortIndex");
      return this;
    }

    public Criteria andSortIndexBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex + " between", value1, value2, "sortIndex");
      return this;
    }

    public Criteria andSortIndexNotBetween(int value1, int value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex + " not between", value1, value2, "sortIndex");
      return this;
    }

    public Criteria andSortIndexNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(
          IProductUITreeNodeBuilderDAO.SortIndex + " not between", value1, value2, "sortIndex");
      return this;
    }
  }
}
